As the overall sophistication and level of integration of modern integrated circuit devices has increased, the number of lines of software code run by a typical integrated circuit device has grown from 10 or 15,000 to 2 million or 3 million. Commonly encountered everyday products from cars to cell phones to medical devices contain embedded computer system integrated circuit devices, which in turn contain increasingly large amounts of complex software. For many systems, that software now accounts for the majority of the cost and almost all of the time-to-market/schedule risk associated with such products. Furthermore, the time-to-market/schedule risk can largely be attributed to the time-consuming task of software debugging.
In order to maintain acceptable cost and schedule performance, embedded programmers (e.g., specialists in programming embedded computer system devices) must improve the way in which the resulting software code is debugged. However, as electronic systems become increasingly more complex, implementing an efficient debugging process proves problematic. Another factor that further exacerbates the problem is the growing use of multicore computer systems. Due to ever-increasing performance demands, embedded systems are increasingly moving toward multicore design.
One prior art approach to the complexity of the debugging process involved the use of simulation-based software development. Instead of utilizing hardware, the software being developed is run on a simulated model of the hardware, enabling the software development process to commence prior to actual silicon availability. The model needs to be accurate enough so that it can run the binaries unchanged. The simulation model, or ISS (instruction set simulator), enables the binaries to run while waiting for an error to be detected or the system to crash. The simulation can then be stepped forward or backward on a cycle by cycle basis to investigate how the error was caused. In this manner, the prior art system simulation processes provide controllability, observability and determinism necessary to solve the problems and bugs that occur during the software development process.
A problem exists however with the debugging processes needed for multicore integrated circuit devices. With multicore designs, software must be dynamically partitioned across the cores, and workload must be equally shared in a parallel processing manner. However, the parallel program introduces a new category of bugs caused by the interaction of multiple tasks, often dependent on the precise timing of execution, memory accesses and communications. These types of bugs are the most difficult to not only reproduce but to understand and resolve.
Additionally, prior art simulation-based software development tools are not adapted to easily handle multicore systems. For example, when one processor hits a breakpoint, the entire system must be frozen. Another problem is the fact that only one debugger can be connected to an simulated device at a time. This makes it difficult or impossible to debug multi-tasking applications, which require, for example, the following of a system call from an application into the kernel of the operating system.
Thus, what is required is a simulation-based software development tool that is adapted to function with multicore systems. A requirement exists for a component that enables the concurrent attachment of multiple debuggers to an ISS. The present invention provides a novel solution to these requirements.